package org.myspringframework.core.util;

import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.HashSet;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;

/**
 * @author jaymin<br>
 * <p>
 * 2020/11/9 23:47
 */
@Slf4j
@SuppressWarnings("all")
public class ClassUtil {
    /**
     * URL协议为文件
     */
    public static final String FILE_PROTOCOL = "file";
    public static final String CLASS = ".class";

    /**
     * 工具类不开放构造函数
     */
    private ClassUtil() {
    }

    /**
     * 获取包下的类集合
     *
     * @param packageName 包名
     * @return 类集合
     */
    public static Set<Class<?>> extractPackageClass(String packageName) {
        // 1. 获取到类加载器
        ClassLoader classLoader = getClassLoader();
        // 2. 通过类加载器获取到加载的资源
        // 用户传入的是cn.com.xxx，此时我们要把里面的 . 变成 /
        String separatedPath = packageName.replace(".", "/");
        URL url = classLoader.getResource(separatedPath);
        if (Objects.isNull(url)) {
            log.warn("unable to retrieve anything from package:" + packageName);
            return null;
        }
        // 3. 依据不同的资源类型，采用不同的方式获取资源的集合
        Set<Class<?>> classSet = null;
        // 过滤出文件类型的资源
        if (url.getProtocol().equalsIgnoreCase(FILE_PROTOCOL)) {
            classSet = new HashSet<>();
            // 获取目录
            File packageDirectory = new File(url.getPath());
            // 遍历该目录下的所有文件
            extractPackageFile(classSet, packageDirectory, packageName);
        }
        return classSet;
    }

    /**
     * 递归获取目标package里面的所有class文件(包括子package里的class文件)<br>
     *
     * @param classSet    装载目标类的集合
     * @param fileSource  文件或者目录
     * @param packageName 包名
     */
    private static void extractPackageFile(Set<Class<?>> classSet, File fileSource, String packageName) {
        // 如果该文件是文件
        if (!fileSource.isDirectory()) {
            return;
        }
        // 如果是一个文件夹，则调用其listFiles()获取文件夹下的文件或者文件夹
        File[] files = fileSource.listFiles(file -> {
            // 如果是文件夹
            if (file.isDirectory()) {
                return true;
            }
            // 如果是文件
            String absolutePath = file.getAbsolutePath();
            if (absolutePath.endsWith(CLASS)) {
                // 如果是class文件,则直接加载到classSet中
                addToClassSet(classSet, absolutePath, packageName);
            }
            return false;
        });
        Optional.ofNullable(files).ifPresent(fileArray -> {
            for (File file : fileArray) {
                // 递归调用
                extractPackageFile(classSet, file, packageName);
            }
        });
    }

    /**
     * 将该路径下的class文件加入到classSet中
     *
     * @param classSet     装载目标类的集合
     * @param absolutePath 绝对路径
     */
    private static void addToClassSet(Set<Class<?>> classSet, String absolutePath, String packageName) {
        // 1. 从class文件的绝对值路径中提取出包含了package的类名
        // 例如: D:/Spring/study-of-spring/src/main/java/com/xjm/HelloServlet.class
        // 期待的结果: com.xjm.HelloServlet
        absolutePath = absolutePath.replace(File.separator, ".");
        // 截断: com.xjm.HelloServlet.class
        String className = absolutePath.substring(absolutePath.indexOf(packageName));
        // result: com.xjm.HelloServlet
        className = className.substring(0, className.lastIndexOf("."));
        // 2. 通过反射机制获取对应的Class对象并加入到classSet中
        Class<?> clazz = loadClass(className);
        classSet.add(clazz);
    }

    /**
     * 获取类加载器ClassLoader
     *
     * @return 当前的ClassLoader实例
     */
    public static ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * 获取Class对象
     *
     * @param className
     * @return
     */
    public static Class<?> loadClass(String className) {
        try {
            Class<?> clazz = Class.forName(className);
            return clazz;
        } catch (ClassNotFoundException e) {
            log.error("load class error:", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 通过class获取对象实例
     *
     * @param clazz
     * @param accessible 是否破坏private
     * @param <T>
     * @return
     */
    public static <T> T newInstance(Class<?> clazz , boolean accessible) {
        try {
            Constructor<?> constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(accessible);
            T result = (T) constructor.newInstance();
            return result;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 设置类的属性值
     * @param field 成员变量
     * @param target 类实例
     * @param value 成员变量的值
     * @param accessible 是否允许设置私有属性
     */
    public static void setField(Field field, Object target, Object value, boolean accessible) {
        field.setAccessible(accessible);
        try {
            field.set(target, value);
        } catch (IllegalAccessException e) {
            throw new RuntimeException("setField error", e);
        }
    }
}
